from google.colab import drive
drive.mount('/content/drive', force_remount=True)

Mounted at /content/drive

!unzip -q "/content/drive/My Drive/traffic_signs.zip" -d "/content"

import os

# Define the paths to the image and label directories
images_dir = "/content/images"
labels_dir = "/content/labels"

# List all files in the directories
image_files = set(f.split('.')[0] for f in os.listdir(images_dir) if f.endswith('.jpg'))
label_files = set(f.split('.')[0] for f in os.listdir(labels_dir) if f.endswith('.txt'))

# Check for missing files
missing_labels = image_files - label_files
missing_images = label_files - image_files

print(f"Missing labels: {missing_labels}")
print(f"Missing images: {missing_images}")

Missing labels: set()
Missing images: set()

from PIL import Image

def check_corrupt_images(images_dir):
    corrupt_images = []
    for filename in os.listdir(images_dir):
        if filename.endswith(".jpg"):  # Adjust file extension if needed
            try:
                with Image.open(os.path.join(images_dir, filename)) as img:
                    img.verify()  # Verify image integrity
            except (IOError, SyntaxError) as e:
                corrupt_images.append(filename)
                print(f"Corrupt image: {filename}, Error: {e}")
    return corrupt_images

corrupt_images = check_corrupt_images(images_dir)

import os
import cv2

def check_empty_images(images_dir):
    empty_images = []
    for filename in os.listdir(images_dir):
        if filename.endswith(".jpg"):  # Adjust file extension if needed
            image_path = os.path.join(images_dir, filename)
            image = cv2.imread(image_path)
            if image is None or image.size == 0:
                empty_images.append(filename)
                print(f"Empty image: {filename}")
    return empty_images

empty_images = check_empty_images(images_dir)

import os

def count_images_and_objects(images_dir, labels_dir):

    num_images = len([f for f in os.listdir(images_dir) if f.endswith(".jpg")])
    num_objects = 0

    for filename in os.listdir(labels_dir):
        if filename.endswith(".txt"):
            label_path = os.path.join(labels_dir, filename)
            with open(label_path, "r") as f:
                num_objects += len(f.readlines())  # Count objects in each label file

    avg_objects_per_image = num_objects / num_images if num_images else 0  # Avoid division by zero

    return num_images, num_objects, avg_objects_per_image

# use:
num_images, num_objects, avg_objects_per_image = count_images_and_objects(images_dir, labels_dir)

print(f"Number of images: {num_images}")
print(f"Number of objects: {num_objects}")
print(f"Average objects per image: {avg_objects_per_image:.2f}")

Number of images: 2817
Number of objects: 6112
Average objects per image: 2.17

# Examine a few label files
for i, filename in enumerate(os.listdir(labels_dir)[:5]):  # Examine the first 5 files
    if filename.endswith(".txt"):
        label_path = os.path.join(labels_dir, filename)
        print(f"--- Contents of {filename} ---")
        with open(label_path, "r") as f:
            for line in f:
                print(line.strip())  # Print each line without extra whitespace
        print("\n")  # Add an empty line between files

--- Contents of 5cbad851dd00e7df.txt ---
Traffic sign 0.0 328.775085 44.8 348.60389399999997
Traffic sign 42.24 293.59430100000003 99.84 307.666359
Traffic sign 337.28 465.018192 433.28 497.639781
Traffic sign 413.44 512.351478 554.24 557.126208


--- Contents of 0ee1826b87554d8b.txt ---
Traffic sign 95.255552 31.077756 526.553088 167.289948


--- Contents of d993b71f9033468e.txt ---
Traffic sign 19.2 61.490295999999994 327.68 211.372378
Traffic sign 275.84 493.202444 312.32 569.4245900000001
Traffic sign 583.04 602.091224 589.44 613.6208260000001
Traffic sign 683.52 3.842972 1000.96 197.92129000000003


--- Contents of 7c90a68215b60773.txt ---
Traffic sign 18.432 186.368256 149.504 303.10425599999996


--- Contents of d593e880e81fb517.txt ---
Traffic sign 203.873141 65.28 359.663141 224.0
Traffic sign 244.26314100000002 0.0 398.771047 136.96
Traffic sign 538.533141 353.92 576.358953 394.24
Traffic sign 538.533141 381.44 576.358953 426.88

from collections import Counter

# Initialize a counter to store class frequencies
class_counts = Counter()

# Iterate through all label files
for filename in os.listdir(labels_dir):
    if filename.endswith(".txt"):
        label_path = os.path.join(labels_dir, filename)
        with open(label_path, "r") as f:
            for line in f:
                parts = line.split()
                class_name = parts[0] + " " + parts[1]  # Combine the first two elements
                class_counts[class_name] += 1  # Increment the count for this class

# Print the class distribution
print("Class Distribution:")
for class_name, count in class_counts.items():
    print(f"{class_name}: {count}")

Class Distribution:
Traffic sign: 6112

import os
import random
import cv2
import matplotlib.pyplot as plt

def visualize_image_with_bbox(image_dir, labels_dir, image_filename):
  """Visualizes an image with its bounding boxes."""

  image_path = os.path.join(image_dir, image_filename)
  label_path = os.path.join(labels_dir, image_filename.replace(".jpg", ".txt"))

  # Load the image
  image = cv2.imread(image_path)
  image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert to RGB

  # Read bounding box information from the label file
  with open(label_path, "r") as f:
    for line in f:
      parts = line.split()
      class_name = parts[0] + " " + parts[1]  # Combine the first two elements
      x_min, y_min, x_max, y_max = map(float, parts[2:])

      # Draw the bounding box
      x_min, y_min, x_max, y_max = int(x_min), int(y_min), int(x_max), int(y_max)
      cv2.rectangle(image, (x_min, y_min), (x_max, y_max), (255, 0, 0), 2)
      cv2.putText(image, class_name, (x_min, y_min - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)

  return image  # Return the image with bounding boxes

def visualize_samples(image_dir, labels_dir, num_samples=8, images_per_row=4):
  """Visualizes a random sample of images with their bounding boxes."""

  image_filenames = [f for f in os.listdir(image_dir) if f.endswith(".jpg")]
  random.shuffle(image_filenames)

  num_images = min(num_samples, len(image_filenames))
  num_rows = (num_images + images_per_row - 1) // images_per_row

  fig, axes = plt.subplots(num_rows, images_per_row, figsize=(15, 10))  # Adjust figsize if needed
  fig.tight_layout()

  for i in range(num_images):
    image_filename = image_filenames[i]
    image_with_bbox = visualize_image_with_bbox(image_dir, labels_dir, image_filename)

    row = i // images_per_row
    col = i % images_per_row

    # Plot on the correct subplot
    if num_rows == 1:  # If only one row, axes is a 1D array
      axes[col].imshow(image_with_bbox)
      axes[col].set_title(image_filename)
      axes[col].axis("off")
    else:
      axes[row, col].imshow(image_with_bbox)
      axes[row, col].set_title(image_filename)
      axes[row, col].axis("off")

  # Hide empty subplots if any
  for i in range(num_images, num_rows * images_per_row):
    row = i // images_per_row
    col = i % images_per_row
    if num_rows == 1:  # If only one row, axes is a 1D array
      axes[col].axis("off")
    else:
      axes[row, col].axis("off")

  plt.tight_layout(pad=0.5)
  plt.show()

# Example usage
visualize_samples(images_dir, labels_dir)

import os
import cv2
import matplotlib.pyplot as plt
import numpy as np

widths = []
heights = []
aspect_ratios = []

for filename in os.listdir(labels_dir):
    if filename.endswith(".txt"):
        label_path = os.path.join(labels_dir, filename)
        image_path = os.path.join(images_dir, filename.replace(".txt", ".jpg"))

        # Read bounding box information from the label file
        with open(label_path, "r") as f:
            for line in f:
                parts = line.split()
                x_min, y_min, x_max, y_max = map(float, parts[2:])

                # Calculate width and height
                width = x_max - x_min
                height = y_max - y_min

                widths.append(width)
                heights.append(height)
                aspect_ratios.append(width / height)

# Calculate statistics
mean_width = np.mean(widths)
mean_height = np.mean(heights)
mean_aspect_ratio = np.mean(aspect_ratios)

# Print statistics
print(f"Mean width: {mean_width}")
print(f"Mean height: {mean_height}")
print(f"Mean aspect ratio: {mean_aspect_ratio}")

# Plot distributions
plt.figure(figsize=(12, 4))

plt.subplot(1, 3, 1)
plt.hist(widths, bins=20)
plt.title("Width Distribution")
plt.xlabel("Width (pixels)")
plt.ylabel("Frequency")

plt.subplot(1, 3, 2)
plt.hist(heights, bins=20)
plt.title("Height Distribution")
plt.xlabel("Height (pixels)")
plt.ylabel("Frequency")

plt.subplot(1, 3, 3)
plt.hist(aspect_ratios, bins=20)
plt.title("Aspect Ratio Distribution")
plt.xlabel("Aspect Ratio")
plt.ylabel("Frequency")

plt.tight_layout()
plt.show()

Mean width: 202.6261274558246
Mean height: 174.58219687794505
Mean aspect ratio: 1.3400642269555623

import matplotlib.pyplot as plt
import numpy as np

# Create a figure and two subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))  # 1 row, 2 columns

# Distribution of Bounding Box Widths
ax1.boxplot(widths, vert=False, showfliers=True)  # showfliers=True to display outliers
ax1.set_title("Distribution of Bounding Box Widths")
ax1.set_xlabel("Width (pixels)")

# Distribution of Bounding Box Heights
ax2.boxplot(heights, vert=False, showfliers=True)  # showfliers=True to display outliers
ax2.set_title("Distribution of Bounding Box Heights")
ax2.set_xlabel("Height (pixels)")

# Adjust spacing between subplots
plt.tight_layout()

# Display the plots
plt.show()

import os
import numpy as np

def identify_outlier_bboxes(labels_dir, low_threshold=0, high_threshold=95, aspect_ratio_threshold=5, thresh='high'):
    """
    Identifies outlier bounding boxes and categorizes them by type.
    """

    widths = []
    heights = []
    aspect_ratios = []
    w_h_outliers = []
    aspect_ratio_outliers = []

    for filename in os.listdir(labels_dir):
        if filename.endswith(".txt"):
            label_path = os.path.join(labels_dir, filename)
            with open(label_path, "r") as f:
                for line in f:
                    parts = line.split()
                    x_min, y_min, x_max, y_max = map(float, parts[2:])

                    width = x_max - x_min
                    height = y_max - y_min
                    aspect_ratio = width / height

                    widths.append(width)
                    heights.append(height)
                    aspect_ratios.append(aspect_ratio)

    # Calculate percentiles for width and height
    width_high_percentile = np.percentile(widths, high_threshold)
    height_high_percentile = np.percentile(heights, high_threshold)
    width_low_percentile = np.percentile(widths, low_threshold)
    height_low_percentile = np.percentile(heights, low_threshold)

    # Identify and categorize outliers
    for filename in os.listdir(labels_dir):
        if filename.endswith(".txt"):
            label_path = os.path.join(labels_dir, filename)
            with open(label_path, "r") as f:
                for line in f:
                    parts = line.split()
                    x_min, y_min, x_max, y_max = map(float, parts[2:])

                    width = x_max - x_min
                    height = y_max - y_min
                    aspect_ratio = width / height

                    if thresh == 'high':
                      if aspect_ratio > aspect_ratio_threshold:
                          aspect_ratio_outliers.append((filename.replace(".txt", ".jpg"), (x_min, y_min, x_max, y_max)))
                      elif width > width_high_percentile or height > height_high_percentile:
                          w_h_outliers.append((filename.replace(".txt", ".jpg"), (x_min, y_min, x_max, y_max)))
                    elif thresh == 'low':
                      if aspect_ratio < aspect_ratio_threshold:
                          aspect_ratio_outliers.append((filename.replace(".txt", ".jpg"), (x_min, y_min, x_max, y_max)))
                      elif (width > width_low_percentile and width < width_high_percentile) or (height > height_low_percentile and height < height_high_percentile):
                          w_h_outliers.append((filename.replace(".txt", ".jpg"), (x_min, y_min, x_max, y_max)))


    return w_h_outliers, aspect_ratio_outliers

# Identify high outliers
w_h_high_outliers, aspect_ratio_high_outliers = identify_outlier_bboxes(labels_dir, high_threshold=95, aspect_ratio_threshold=5, thresh='high')

# Identify low outliers
w_h_low_outliers, aspect_ratio_low_outliers = identify_outlier_bboxes(labels_dir, high_threshold=5, aspect_ratio_threshold=0.2, thresh='low')

# Print the number of outliers in each category
print("High Width & Height Outliers:", len(w_h_high_outliers))
print("High Aspect Ratio Outliers:", len(aspect_ratio_high_outliers))
print("Total High Outliers:", len(w_h_high_outliers) + len(aspect_ratio_high_outliers))

print("\nLow Width & Height Outliers:", len(w_h_low_outliers))
print("Low Aspect Ratio Outliers:", len(aspect_ratio_low_outliers))
print("Total Low Outliers:", len(w_h_low_outliers) + len(aspect_ratio_low_outliers))

High Width & Height Outliers: 420
High Aspect Ratio Outliers: 76
Total High Outliers: 496

Low Width & Height Outliers: 466
Low Aspect Ratio Outliers: 11
Total Low Outliers: 477

import os
import cv2
import matplotlib.pyplot as plt
import random

def visualize_outliers(image_dir, labels_dir, outlier_bboxes, images_per_row=4, figsize=(15, 10), num_images_to_print=8):
    """Visualizes images with outlier bounding boxes highlighted."""

    num_images = len(outlier_bboxes)

    # Limit the number of images to print if specified
    if num_images_to_print is not None:
        num_images = min(num_images, num_images_to_print)

    # Select a random sample of images
    random_samples = random.sample(outlier_bboxes, num_images)

    num_rows = (num_images + images_per_row - 1) // images_per_row  # Calculate number of rows

    fig, axes = plt.subplots(num_rows, images_per_row, figsize=figsize)
    fig.tight_layout()  # Adjust spacing between subplots

    for i, (image_filename, bbox) in enumerate(random_samples):  # Iterate over random samples
        image_path = os.path.join(image_dir, image_filename)
        image = cv2.imread(image_path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        # Draw the outlier bounding box in red
        x_min, y_min, x_max, y_max = map(int, bbox)
        cv2.rectangle(image, (x_min, y_min), (x_max, y_max), (255, 0, 0), 2)

        row = i // images_per_row
        col = i % images_per_row

        # Check if axes is 1-dimensional and access accordingly
        if num_rows == 1 or images_per_row == 1:
            ax = axes[col] if num_rows == 1 else axes[row] #If only one row or one column, access using a single index
        else:
            ax = axes[row, col]  # Access using two indices for 2D structure

        ax.imshow(image)
        ax.set_title(image_filename, fontsize=8)  # Smaller title font size
        ax.axis("off")

    # Hide empty subplots if any
    for i in range(num_images, num_rows * images_per_row):
        row = i // images_per_row
        col = i % images_per_row
        # Check if axes is 1-dimensional and access accordingly
        if num_rows == 1 or images_per_row == 1:
            ax = axes[col] if num_rows == 1 else axes[row] #If only one row or one column, access using a single index
        else:
            ax = axes[row, col]  # Access using two indices for 2D structure
        ax.axis("off")

    plt.tight_layout(pad=0.5)
    plt.show()

visualize_outliers(images_dir, labels_dir, aspect_ratio_high_outliers)

_, aspect_ratio_higher_outliers = identify_outlier_bboxes(labels_dir, aspect_ratio_threshold=8)
visualize_outliers(images_dir, labels_dir, aspect_ratio_higher_outliers)

visualize_outliers(images_dir, labels_dir, w_h_high_outliers)

visualize_outliers(images_dir, labels_dir, aspect_ratio_low_outliers)

# Start with default - low 5%
visualize_outliers(images_dir, labels_dir, w_h_low_outliers)

w_h_low_outliers, _ = identify_outlier_bboxes(labels_dir, low_threshold=5 , high_threshold=10, aspect_ratio_threshold=0, thresh='low')
print(len(w_h_low_outliers))
visualize_outliers(images_dir, labels_dir, w_h_low_outliers)

467

w_h_low_outliers, _ = identify_outlier_bboxes(labels_dir, low_threshold=10 , high_threshold=20, aspect_ratio_threshold=0, thresh='low')
print(len(w_h_low_outliers))
visualize_outliers(images_dir, labels_dir, w_h_low_outliers)

987

w_h_low_outliers, _ = identify_outlier_bboxes(labels_dir, low_threshold=20 , high_threshold=25, aspect_ratio_threshold=0, thresh='low')
visualize_outliers(images_dir, labels_dir, w_h_low_outliers)

import os
import matplotlib.pyplot as plt
import numpy as np

def calculate_object_size_distribution(images_dir, labels_dir):

  object_sizes = []

  for filename in os.listdir(labels_dir):
    if filename.endswith(".txt"):
      label_path = os.path.join(labels_dir, filename)
      image_path = os.path.join(images_dir, filename.replace(".txt", ".jpg"))

      # Get image dimensions
      img = plt.imread(image_path)

      # Check the number of dimensions in img.shape
      if len(img.shape) == 3:  # If RGB image
          image_height, image_width, _ = img.shape
      elif len(img.shape) == 2:  # If grayscale image
          image_height, image_width = img.shape
      else:
          raise ValueError(f"Unexpected image shape: {img.shape} for image {image_path}")

      image_area = image_height * image_width

      # Read object labels
      with open(label_path, "r") as f:
        for line in f:
          parts = line.split()
          class_name = parts[0] + " " + parts[1]  # Combine the first two elements
          x_min, y_min, x_max, y_max = map(float, parts[2:])

          object_width = x_max - x_min
          object_height = y_max - y_min
          object_area = object_width * object_height

          # Calculate object size relative to image area
          relative_size = object_area / image_area * 100
          object_sizes.append(relative_size)

  return object_sizes

object_sizes = calculate_object_size_distribution(images_dir, labels_dir)

import matplotlib.pyplot as plt
def plot_object_size_distribution(object_sizes, min_threshold=0, max_threshold=100):

  # Filter bbox areas based on the defined thresholds
  filtered_object_sizes = [object for object in object_sizes if min_threshold <= object <= max_threshold]

  # Plotting histogram of bounding box areas with specified thresholds
  plt.figure(figsize=(10, 5))
  plt.hist(filtered_object_sizes, bins=50, color='skyblue', edgecolor='black')
  plt.title("Distribution of Bounding Box Areas")
  plt.xlabel("Object Size % From Image Area")
  plt.ylabel("Number of Objects")
  plt.grid(True)
  plt.tight_layout()
  plt.show()

plot_object_size_distribution(object_sizes)

plot_object_size_distribution(object_sizes,0,10)

plot_object_size_distribution(object_sizes,0,1)

import os
import cv2
import numpy as np
import matplotlib.pyplot as plt
import random



# Directories (lowercase)
images_dir = "/content/images"
labels_dir = "/content/labels"

# Number of images to process
max_images = 5
processed_count = 0

image_files = [f for f in os.listdir(images_dir) if f.endswith((".jpg", ".png"))]
random.shuffle(image_files)

for filename in image_files:
    if not (filename.endswith(".jpg") or filename.endswith(".png")):
        continue

    print(f"\nProcessing image: {filename}")
    image_path = os.path.join(images_dir, filename)
    label_path = os.path.join(labels_dir, os.path.splitext(filename)[0] + ".txt")

    if not os.path.exists(label_path):
        print(f"→ Label file not found: {label_path}")
        continue

    image = cv2.imread(image_path)
    if image is None:
        print(f"→ Failed to read image: {image_path}")
        continue

    image_height, image_width = image.shape[:2]

    with open(label_path, 'r') as f:
        lines = f.readlines()

    if not lines:
        print(f"→ Label file is empty: {label_path}")
        continue

    found_valid_object = False

    for line in lines:
        line = line.strip()
        if not line.startswith("Traffic sign"):
            continue

        line = line.replace("Traffic sign", "").strip()
        parts = line.split()
        if len(parts) != 4:
            continue

        try:
            x_min, y_min, x_max, y_max = [int(float(v)) for v in parts]
        except ValueError:
            print(f"→ Invalid bounding box values: {parts}")
            continue

        # Clamp values
        x_min = max(0, min(x_min, image_width - 1))
        x_max = max(0, min(x_max, image_width - 1))
        y_min = max(0, min(y_min, image_height - 1))
        y_max = max(0, min(y_max, image_height - 1))

        if x_max <= x_min or y_max <= y_min:
            continue

        # Draw bbox on original image
        image_with_bbox = image.copy()
        cv2.rectangle(image_with_bbox, (x_min, y_min), (x_max, y_max), (255, 0, 0), 2)

        # Add padding (e.g., 10%)
        padding_ratio = 0.1

        bbox_width = x_max - x_min
        bbox_height = y_max - y_min

        x_pad = int(bbox_width * padding_ratio)
        y_pad = int(bbox_height * padding_ratio)

        # Expand bbox with clamping
        x1 = max(0, x_min - x_pad)
        y1 = max(0, y_min - y_pad)
        x2 = min(image_width - 1, x_max + x_pad)
        y2 = min(image_height - 1, y_max + y_pad)

        cropped = image[y1:y2, x1:x2]
        if cropped.size == 0:
            continue

        # Convert to grayscale and detect contours
        gray = cv2.cvtColor(cropped, cv2.COLOR_BGR2GRAY)
        edges = cv2.Canny(gray, 50, 150)
        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        if not contours:
            continue

        # Draw contours on cropped image
        output = cropped.copy()
        # Find the largest contour (by area)
        largest_contour = max(contours, key=cv2.contourArea)

        # Draw only the largest contour
        cv2.drawContours(output, [largest_contour], -1, (0, 255, 0), 2)

        # Display results
        plt.figure(figsize=(12, 4))
        plt.subplot(1, 3, 1)
        plt.title("Original with BBox")
        plt.imshow(cv2.cvtColor(image_with_bbox, cv2.COLOR_BGR2RGB))
        plt.axis("off")

        plt.subplot(1, 3, 2)
        plt.title("Cropped")
        plt.imshow(cv2.cvtColor(cropped, cv2.COLOR_BGR2RGB))
        plt.axis("off")

        plt.subplot(1, 3, 3)
        plt.title("Contours")
        plt.imshow(cv2.cvtColor(output, cv2.COLOR_BGR2RGB))
        plt.axis("off")

        plt.tight_layout()
        plt.show()

        found_valid_object = True
        processed_count += 1
        if processed_count >= max_images:
            break

    if not found_valid_object:
        print("→ No valid objects found in this image.")

    if processed_count >= max_images:
        break

Processing image: 20d25f560a03f2f7.jpg

Processing image: 00d0ae2a372fe5e1.jpg

Processing image: ebe73f545761804d.jpg

Processing image: 96eda76a3c9b9a9f.jpg

import os
import cv2
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
import random

# Directories (edit if needed)
images_dir = "/content/images"
labels_dir = "/content/labels"

# Parameters
max_images = 5
padding_ratio = 0.1
k_clusters = 3

image_files = [f for f in os.listdir(images_dir) if f.endswith((".jpg", ".png"))]
random.shuffle(image_files)

def show_dominant_colors(image, colors, title="Dominant Colors"):
    plt.figure(figsize=(8, 4))

    plt.subplot(1, 2, 1)
    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
    plt.axis("off")
    plt.title("Traffic Sign")

    plt.subplot(1, 2, 2)
    palette = np.zeros((50, 300, 3), dtype=np.uint8)
    step = 300 // len(colors)
    for i, color in enumerate(colors):
        palette[:, i*step:(i+1)*step] = np.uint8(color)
    plt.imshow(cv2.cvtColor(palette, cv2.COLOR_BGR2RGB))
    plt.axis("off")
    plt.title(title)
    plt.show()

count = 0
for filename in image_files:
    if count >= max_images:
        break

    image_path = os.path.join(images_dir, filename)
    label_path = os.path.join(labels_dir, os.path.splitext(filename)[0] + ".txt")

    if not os.path.exists(label_path):
        continue

    image = cv2.imread(image_path)
    if image is None:
        continue

    image_height, image_width = image.shape[:2]

    with open(label_path, "r") as f:
        lines = f.readlines()

    for line in lines:
        line = line.strip()
        if not line.startswith("Traffic sign"):
            continue

        line = line.replace("Traffic sign", "").strip()
        parts = line.split()
        if len(parts) != 4:
            continue

        try:
            x_min, y_min, x_max, y_max = [int(float(v)) for v in parts]
        except ValueError:
            print(f"→ Invalid bounding box values: {parts}")
            continue

        x_min, x_max = int(x_min), int(x_max)
        y_min, y_max = int(y_min), int(y_max)

        # Add padding
        bbox_width = x_max - x_min
        bbox_height = y_max - y_min
        x_pad = int(bbox_width * padding_ratio)
        y_pad = int(bbox_height * padding_ratio)
        x1 = max(0, x_min - x_pad)
        y1 = max(0, y_min - y_pad)
        x2 = min(image_width - 1, x_max + x_pad)
        y2 = min(image_height - 1, y_max + y_pad)

        cropped = image[y1:y2, x1:x2]
        if cropped.size == 0:
            continue

        # Reshape and filter
        pixels = cropped.reshape(-1, 3)
        pixels = pixels[np.any(pixels < 250, axis=1)]  # Remove white-ish pixels

        if len(pixels) < k_clusters:
            continue

        # KMeans clustering
        kmeans = KMeans(n_clusters=k_clusters, n_init="auto", random_state=42)
        kmeans.fit(pixels)
        dominant_colors = kmeans.cluster_centers_

        # Show
        show_dominant_colors(cropped, dominant_colors)
        count += 1
        break

import os
from PIL import Image

def get_image_dimensions(image_path):
    """Gets the width and height of an image."""
    with Image.open(image_path) as img:
        width, height = img.size
    return width, height

def convert_to_yolo_format(label_line, image_width, image_height):
    """Converts a label line to YOLO format (single class)."""
    parts = label_line.split()
    x_min, y_min, x_max, y_max = map(float, parts[2:])

    # Calculate center, width, and height
    center_x = (x_min + x_max) / 2 / image_width
    center_y = (y_min + y_max) / 2 / image_height
    width = (x_max - x_min) / image_width
    height = (y_max - y_min) / image_height

    # Single class, so class_id is always 0
    class_id = 0

    return f"{class_id} {center_x} {center_y} {width} {height}"

def convert_labels_to_yolo(images_dir, labels_dir):
    """Converts all labels to YOLO format (single class), replacing existing files."""

    for filename in os.listdir(labels_dir):
        if filename.endswith(".txt"):
            label_path = os.path.join(labels_dir, filename)
            image_path = os.path.join(images_dir, filename.replace(".txt", ".jpg"))

            image_width, image_height = get_image_dimensions(image_path)

            # Create a temporary file to store converted lines
            temp_file_path = label_path + ".tmp"
            with open(label_path, "r") as infile, open(temp_file_path, "w") as outfile:
                for line in infile:
                    yolo_line = convert_to_yolo_format(line, image_width, image_height)
                    outfile.write(yolo_line + "\n")

            # Replace the original file with the temporary file
            os.replace(temp_file_path, label_path)

convert_labels_to_yolo(images_dir, labels_dir)

# Examine a few label files
for i, filename in enumerate(os.listdir(labels_dir)[:5]):  # Examine the first 5 files
    if filename.endswith(".txt"):
        label_path = os.path.join(labels_dir, filename)
        print(f"--- Contents of {filename} ---")
        with open(label_path, "r") as f:
            for line in f:
                print(line.strip())  # Print each line without extra whitespace
        print("\n")  # Add an empty line between files

--- Contents of 0101abaff92fa0b2.txt ---
0 0.5484375 0.4883335 0.514375 0.7116669999999999


--- Contents of 27ee34e8e4de0f8b.txt ---
0 0.530236 0.5384374999999999 0.08406999999999999 0.05312499999999998
0 0.6084069999999999 0.5453125 0.07227199999999995 0.02562500000000001


--- Contents of ae1639138ec7ae08.txt ---
0 0.5033329999999999 0.5640625 0.9500000000000001 0.6443749999999999


--- Contents of 508166b162fe18b0.txt ---
0 0.24625 0.4529165 0.034999999999999976 0.08083300000000009
0 0.7571875 0.48041700000000004 0.04937499999999995 0.07750000000000012


--- Contents of b8309756fd658c32.txt ---
0 0.5053125 0.4870295 0.45062499999999994 0.579079

import os
import random
import cv2
import matplotlib.pyplot as plt

def visualize_random_yolo_images(image_dir, labels_dir, num_images=5):
    """Visualizes a random set of images with YOLO bounding boxes."""

    image_filenames = [f for f in os.listdir(image_dir) if f.endswith(".jpg")]
    random_images = random.sample(image_filenames, num_images)

    for image_filename in random_images:
        image_path = os.path.join(image_dir, image_filename)
        label_path = os.path.join(labels_dir, image_filename.replace(".jpg", ".txt"))

        # Load the image
        image = cv2.imread(image_path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert to RGB

        # Read bounding box information from the label file
        with open(label_path, "r") as f:
            for line in f:
                parts = line.split()
                class_id, center_x, center_y, width, height = map(float, parts)

                # Get image dimensions
                image_height, image_width, _ = image.shape

                # Calculate bounding box coordinates
                x_min = int((center_x - width / 2) * image_width)
                y_min = int((center_y - height / 2) * image_height)
                x_max = int((center_x + width / 2) * image_width)
                y_max = int((center_y + height / 2) * image_height)

                # Draw the bounding box
                cv2.rectangle(image, (x_min, y_min), (x_max, y_max), (255, 0, 0), 2)

        # Display the image
        plt.imshow(image)
        plt.title(image_filename)
        plt.axis("off")
        plt.show()

# Example usage:
visualize_random_yolo_images(images_dir, labels_dir)  # Visualize 5 random images

#install the split-folders library, which will be used to split the dataset into train, validation, and test sets.
!pip install split-folders

Collecting split-folders
  Downloading split_folders-0.5.1-py3-none-any.whl.metadata (6.2 kB)
Downloading split_folders-0.5.1-py3-none-any.whl (8.4 kB)
Installing collected packages: split-folders
Successfully installed split-folders-0.5.1

# Move the images and labels folders into a new directory

import shutil
import os

# Define the source and destination paths
source_images_dir = "/content/images"
source_labels_dir = "/content/labels"
destination_dir = "/content/data"

# Create the destination directory if it doesn't exist
os.makedirs(destination_dir, exist_ok=True)

# Move the images folder
shutil.move(source_images_dir, destination_dir)

# Move the labels folder
shutil.move(source_labels_dir, destination_dir)

'/content/data/labels'

import splitfolders

input_folder = "/content/data"
output_folder = "/content/split_data"
splitfolders.ratio(input_folder, output=output_folder, seed=1337, ratio=(0.7, 0.2, 0.1))

Copying files: 5634 files [00:01, 3013.20 files/s]

import shutil
import os

# Define source and destination paths
source_dir = "/content/split_data"
yolo_dataset_dir = "/content/yolo_dataset"  # Create a new folder for YOLO dataset

# Create the YOLO dataset directory structure if it doesn't exist
os.makedirs(os.path.join(yolo_dataset_dir, "images", "train"), exist_ok=True)
os.makedirs(os.path.join(yolo_dataset_dir, "images", "val"), exist_ok=True)
os.makedirs(os.path.join(yolo_dataset_dir, "images", "test"), exist_ok=True)
os.makedirs(os.path.join(yolo_dataset_dir, "labels", "train"), exist_ok=True)
os.makedirs(os.path.join(yolo_dataset_dir, "labels", "val"), exist_ok=True)
os.makedirs(os.path.join(yolo_dataset_dir, "labels", "test"), exist_ok=True)

# Move images and labels to the corresponding YOLO dataset folders
for data_type in ["train", "val", "test"]:
    shutil.move(os.path.join(source_dir, data_type, "images"),
                os.path.join(yolo_dataset_dir, "images", data_type))
    shutil.move(os.path.join(source_dir, data_type, "labels"),
                os.path.join(yolo_dataset_dir, "labels", data_type))

import shutil
import os

def consolidate_folders(root_dir):
    for data_type in ['train', 'val', 'test']:
        # Path to the extra images folder
        extra_images_dir = os.path.join(root_dir, 'images', data_type, 'images')
        # Path to the correct destination folder
        dest_images_dir = os.path.join(root_dir, 'images', data_type)

        # If the extra images folder exists, move its contents to the correct folder
        if os.path.exists(extra_images_dir):
            for filename in os.listdir(extra_images_dir):
                src_path = os.path.join(extra_images_dir, filename)
                dest_path = os.path.join(dest_images_dir, filename)
                shutil.move(src_path, dest_path)

            # Remove the now empty extra images folder
            os.rmdir(extra_images_dir)

# Adjust the path if needed
yolo_dataset_dir = '/content/yolo_dataset'

consolidate_folders(yolo_dataset_dir)

import shutil
import os

# Define the source and destination paths
source_dir = "/content/content/yolo_dataset"
destination_dir = "/content/yolo_dataset"

# Move the yolo_dataset folder
shutil.move(source_dir, destination_dir)

'/content/yolo_dataset'

import os

def count_files_in_yolo_dataset(dataset_path):
    """Counts the number of images and labels in each split of the YOLO dataset."""

    splits = ["train", "val", "test"]
    file_types = ["images", "labels"]
    counts = {}

    for split in splits:
        counts[split] = {}
        for file_type in file_types:
            folder_path = os.path.join(dataset_path, file_type, split)
            num_files = len([f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))])
            counts[split][file_type] = num_files

    return counts

# Example usage:
dataset_path = "/content/yolo_dataset"  # Replace with your dataset path
file_counts = count_files_in_yolo_dataset(dataset_path)

for split, split_counts in file_counts.items():
    print(f"Split: {split}")
    for file_type, count in split_counts.items():
        print(f"  Number of {file_type}: {count}")

Split: train
  Number of images: 1971
  Number of labels: 1972
Split: val
  Number of images: 563
  Number of labels: 563
Split: test
  Number of images: 283
  Number of labels: 283

import os

def compare_image_label_names(dataset_path):
    """Compares image names and label names for all 3 sets in the YOLO dataset."""

    splits = ["train", "val", "test"]
    mismatches = {}

    for split in splits:
        image_dir = os.path.join(dataset_path, "images", split)  # Path to images for the split
        label_dir = os.path.join(dataset_path, "labels", split)  # Path to labels for the split

        # Get sets of image and label filenames without extensions
        image_files = set(f.split('.')[0] for f in os.listdir(image_dir) if f.endswith('.jpg'))
        label_files = set(f.split('.')[0] for f in os.listdir(label_dir) if f.endswith('.txt'))

        # Find mismatches
        missing_labels = image_files - label_files  # Images without corresponding labels
        missing_images = label_files - image_files  # Labels without corresponding images

        mismatches[split] = {
            "missing_labels": list(missing_labels),
            "missing_images": list(missing_images)
        }

    return mismatches

# Example usage:
dataset_path = "/content/yolo_dataset"  # Replace with your dataset path
mismatches = compare_image_label_names(dataset_path)

for split, split_mismatches in mismatches.items():
    print(f"Split: {split}")
    print(f"  Missing labels for images: {split_mismatches['missing_labels']}")
    print(f"  Missing images for labels: {split_mismatches['missing_images']}")

Split: train
  Missing labels for images: []
  Missing images for labels: []
Split: val
  Missing labels for images: []
  Missing images for labels: []
Split: test
  Missing labels for images: []
  Missing images for labels: []

# Create data.yaml file
data_yaml_path = os.path.join(yolo_dataset_dir, "data.yaml")
with open(data_yaml_path, "w") as f:
    f.write(f"train: {os.path.join(yolo_dataset_dir, 'images', 'train')}\n")
    f.write(f"val: {os.path.join(yolo_dataset_dir, 'images', 'val')}\n")
    f.write(f"test: {os.path.join(yolo_dataset_dir, 'images', 'test')}\n\n")
    f.write("nc: 1\n")  #  number of classes
    f.write("names: ['sign']")  # class names

# Save the prepared data in Google Drive
!zip -r /content/drive/MyDrive/yolo_dataset_ready.zip /content/yolo_dataset

!unzip -q /content/drive/MyDrive/yolo_dataset_ready.zip

import shutil
import os

# Define the source and destination paths
source_dir = "/content/content/yolo_dataset"
destination_dir = "/content/yolo_dataset"

# Check if the source directory exists
if os.path.exists(source_dir):
  # Move the directory
  shutil.move(source_dir, destination_dir)
  print(f"Moved '{source_dir}' to '{destination_dir}'")
else:
  print(f"Source directory '{source_dir}' not found.")

Moved '/content/content/yolo_dataset' to '/content/yolo_dataset'

!pip install ultralytics

Collecting ultralytics
  Downloading ultralytics-8.3.109-py3-none-any.whl.metadata (37 kB)
Requirement already satisfied: numpy<=2.1.1,>=1.23.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (2.0.2)
Requirement already satisfied: matplotlib>=3.3.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (3.10.0)
Requirement already satisfied: opencv-python>=4.6.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (4.11.0.86)
Requirement already satisfied: pillow>=7.1.2 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (11.1.0)
Requirement already satisfied: pyyaml>=5.3.1 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (6.0.2)
Requirement already satisfied: requests>=2.23.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (2.32.3)
Requirement already satisfied: scipy>=1.4.1 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (1.14.1)
Requirement already satisfied: torch>=1.8.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (2.6.0+cu124)
Requirement already satisfied: torchvision>=0.9.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (0.21.0+cu124)
Requirement already satisfied: tqdm>=4.64.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (4.67.1)
Requirement already satisfied: psutil in /usr/local/lib/python3.11/dist-packages (from ultralytics) (5.9.5)
Requirement already satisfied: py-cpuinfo in /usr/local/lib/python3.11/dist-packages (from ultralytics) (9.0.0)
Requirement already satisfied: pandas>=1.1.4 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (2.2.2)
Requirement already satisfied: seaborn>=0.11.0 in /usr/local/lib/python3.11/dist-packages (from ultralytics) (0.13.2)
Collecting ultralytics-thop>=2.0.0 (from ultralytics)
  Downloading ultralytics_thop-2.0.14-py3-none-any.whl.metadata (9.4 kB)
Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.3.0->ultralytics) (1.3.1)
Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.3.0->ultralytics) (0.12.1)
Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.3.0->ultralytics) (4.57.0)
Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.3.0->ultralytics) (1.4.8)
Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.3.0->ultralytics) (24.2)
Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.3.0->ultralytics) (3.2.3)
Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.3.0->ultralytics) (2.8.2)
Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.1.4->ultralytics) (2025.2)
Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.1.4->ultralytics) (2025.2)
Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests>=2.23.0->ultralytics) (3.4.1)
Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests>=2.23.0->ultralytics) (3.10)
Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests>=2.23.0->ultralytics) (2.3.0)
Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests>=2.23.0->ultralytics) (2025.1.31)
Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (3.18.0)
Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (4.13.1)
Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (3.4.2)
Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (3.1.6)
Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (2025.3.2)
Collecting nvidia-cuda-nvrtc-cu12==12.4.127 (from torch>=1.8.0->ultralytics)
  Downloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)
Collecting nvidia-cuda-runtime-cu12==12.4.127 (from torch>=1.8.0->ultralytics)
  Downloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)
Collecting nvidia-cuda-cupti-cu12==12.4.127 (from torch>=1.8.0->ultralytics)
  Downloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)
Collecting nvidia-cudnn-cu12==9.1.0.70 (from torch>=1.8.0->ultralytics)
  Downloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)
Collecting nvidia-cublas-cu12==12.4.5.8 (from torch>=1.8.0->ultralytics)
  Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)
Collecting nvidia-cufft-cu12==11.2.1.3 (from torch>=1.8.0->ultralytics)
  Downloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)
Collecting nvidia-curand-cu12==10.3.5.147 (from torch>=1.8.0->ultralytics)
  Downloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)
Collecting nvidia-cusolver-cu12==11.6.1.9 (from torch>=1.8.0->ultralytics)
  Downloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)
Collecting nvidia-cusparse-cu12==12.3.1.170 (from torch>=1.8.0->ultralytics)
  Downloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)
Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (0.6.2)
Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (2.21.5)
Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (12.4.127)
Collecting nvidia-nvjitlink-cu12==12.4.127 (from torch>=1.8.0->ultralytics)
  Downloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)
Requirement already satisfied: triton==3.2.0 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (3.2.0)
Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch>=1.8.0->ultralytics) (1.13.1)
Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch>=1.8.0->ultralytics) (1.3.0)
Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.7->matplotlib>=3.3.0->ultralytics) (1.17.0)
Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch>=1.8.0->ultralytics) (3.0.2)
Downloading ultralytics-8.3.109-py3-none-any.whl (974 kB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 974.8/974.8 kB 54.5 MB/s eta 0:00:00
Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl (363.4 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 363.4/363.4 MB 2.9 MB/s eta 0:00:00
Downloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (13.8 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 13.8/13.8 MB 113.4 MB/s eta 0:00:00
Downloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (24.6 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 24.6/24.6 MB 89.9 MB/s eta 0:00:00
Downloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (883 kB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 883.7/883.7 kB 55.3 MB/s eta 0:00:00
Downloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl (664.8 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 664.8/664.8 MB 1.6 MB/s eta 0:00:00
Downloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl (211.5 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 211.5/211.5 MB 10.6 MB/s eta 0:00:00
Downloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl (56.3 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 56.3/56.3 MB 41.3 MB/s eta 0:00:00
Downloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl (127.9 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 127.9/127.9 MB 18.9 MB/s eta 0:00:00
Downloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl (207.5 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 207.5/207.5 MB 5.3 MB/s eta 0:00:00
Downloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (21.1 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 21.1/21.1 MB 96.3 MB/s eta 0:00:00
Downloading ultralytics_thop-2.0.14-py3-none-any.whl (26 kB)
Installing collected packages: nvidia-nvjitlink-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12, ultralytics-thop, ultralytics
  Attempting uninstall: nvidia-nvjitlink-cu12
    Found existing installation: nvidia-nvjitlink-cu12 12.5.82
    Uninstalling nvidia-nvjitlink-cu12-12.5.82:
      Successfully uninstalled nvidia-nvjitlink-cu12-12.5.82
  Attempting uninstall: nvidia-curand-cu12
    Found existing installation: nvidia-curand-cu12 10.3.6.82
    Uninstalling nvidia-curand-cu12-10.3.6.82:
      Successfully uninstalled nvidia-curand-cu12-10.3.6.82
  Attempting uninstall: nvidia-cufft-cu12
    Found existing installation: nvidia-cufft-cu12 11.2.3.61
    Uninstalling nvidia-cufft-cu12-11.2.3.61:
      Successfully uninstalled nvidia-cufft-cu12-11.2.3.61
  Attempting uninstall: nvidia-cuda-runtime-cu12
    Found existing installation: nvidia-cuda-runtime-cu12 12.5.82
    Uninstalling nvidia-cuda-runtime-cu12-12.5.82:
      Successfully uninstalled nvidia-cuda-runtime-cu12-12.5.82
  Attempting uninstall: nvidia-cuda-nvrtc-cu12
    Found existing installation: nvidia-cuda-nvrtc-cu12 12.5.82
    Uninstalling nvidia-cuda-nvrtc-cu12-12.5.82:
      Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.5.82
  Attempting uninstall: nvidia-cuda-cupti-cu12
    Found existing installation: nvidia-cuda-cupti-cu12 12.5.82
    Uninstalling nvidia-cuda-cupti-cu12-12.5.82:
      Successfully uninstalled nvidia-cuda-cupti-cu12-12.5.82
  Attempting uninstall: nvidia-cublas-cu12
    Found existing installation: nvidia-cublas-cu12 12.5.3.2
    Uninstalling nvidia-cublas-cu12-12.5.3.2:
      Successfully uninstalled nvidia-cublas-cu12-12.5.3.2
  Attempting uninstall: nvidia-cusparse-cu12
    Found existing installation: nvidia-cusparse-cu12 12.5.1.3
    Uninstalling nvidia-cusparse-cu12-12.5.1.3:
      Successfully uninstalled nvidia-cusparse-cu12-12.5.1.3
  Attempting uninstall: nvidia-cudnn-cu12
    Found existing installation: nvidia-cudnn-cu12 9.3.0.75
    Uninstalling nvidia-cudnn-cu12-9.3.0.75:
      Successfully uninstalled nvidia-cudnn-cu12-9.3.0.75
  Attempting uninstall: nvidia-cusolver-cu12
    Found existing installation: nvidia-cusolver-cu12 11.6.3.83
    Uninstalling nvidia-cusolver-cu12-11.6.3.83:
      Successfully uninstalled nvidia-cusolver-cu12-11.6.3.83
Successfully installed nvidia-cublas-cu12-12.4.5.8 nvidia-cuda-cupti-cu12-12.4.127 nvidia-cuda-nvrtc-cu12-12.4.127 nvidia-cuda-runtime-cu12-12.4.127 nvidia-cudnn-cu12-9.1.0.70 nvidia-cufft-cu12-11.2.1.3 nvidia-curand-cu12-10.3.5.147 nvidia-cusolver-cu12-11.6.1.9 nvidia-cusparse-cu12-12.3.1.170 nvidia-nvjitlink-cu12-12.4.127 ultralytics-8.3.109 ultralytics-thop-2.0.14

from ultralytics import YOLO
import os

model = YOLO('yolo11n')  # Load the YOLOv11n model

save_dir = "/content/drive/MyDrive/yolo_training"

results = model.train(data='/content/yolo_dataset/data.yaml', epochs=100, patience=20, imgsz=640, save_dir=save_dir)

Ultralytics 8.3.75 🚀 Python-3.11.11 torch-2.5.1+cu124 CUDA:0 (NVIDIA L4, 22693MiB)
engine/trainer: task=detect, mode=train, model=yolo11n.pt, data=/content/yolo_dataset/data.yaml, epochs=100, time=None, patience=20, batch=16, imgsz=640, save=True, save_period=-1, cache=False, device=None, workers=8, project=None, name=train5, exist_ok=False, pretrained=True, optimizer=auto, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=False, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=True, opset=None, workspace=None, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, copy_paste_mode=flip, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=runs/detect/train5
Overriding model.yaml nc=80 with nc=1

                   from  n    params  module                                       arguments                     
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]                 
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]                
  2                  -1  1      6640  ultralytics.nn.modules.block.C3k2            [32, 64, 1, False, 0.25]      
  3                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]                
  4                  -1  1     26080  ultralytics.nn.modules.block.C3k2            [64, 128, 1, False, 0.25]     
  5                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              
  6                  -1  1     87040  ultralytics.nn.modules.block.C3k2            [128, 128, 1, True]           
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]              
  8                  -1  1    346112  ultralytics.nn.modules.block.C3k2            [256, 256, 1, True]           
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]                 
 10                  -1  1    249728  ultralytics.nn.modules.block.C2PSA           [256, 256, 1]                 
 11                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 12             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 13                  -1  1    111296  ultralytics.nn.modules.block.C3k2            [384, 128, 1, False]          
 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 15             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 16                  -1  1     32096  ultralytics.nn.modules.block.C3k2            [256, 64, 1, False]           
 17                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]                
 18            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 19                  -1  1     86720  ultralytics.nn.modules.block.C3k2            [192, 128, 1, False]          
 20                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              
 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 22                  -1  1    378880  ultralytics.nn.modules.block.C3k2            [384, 256, 1, True]           
 23        [16, 19, 22]  1    430867  ultralytics.nn.modules.head.Detect           [1, [64, 128, 256]]           
YOLO11n summary: 319 layers, 2,590,035 parameters, 2,590,019 gradients, 6.4 GFLOPs

Transferred 448/499 items from pretrained weights
TensorBoard: Start with 'tensorboard --logdir runs/detect/train5', view at http://localhost:6006/
Freezing layer 'model.23.dfl.conv.weight'
AMP: running Automatic Mixed Precision (AMP) checks...
AMP: checks passed ✅

train: Scanning /content/yolo_dataset/labels/train.cache... 1971 images, 0 backgrounds, 0 corrupt: 100%|██████████| 1971/1971 [00:00<?, ?it/s]

albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1.0, 4.0), tile_grid_size=(8, 8))

val: Scanning /content/yolo_dataset/labels/val.cache... 563 images, 0 backgrounds, 0 corrupt: 100%|██████████| 563/563 [00:00<?, ?it/s]

Plotting labels to runs/detect/train5/labels.jpg... 
optimizer: 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... 
optimizer: AdamW(lr=0.002, momentum=0.9) with parameter groups 81 weight(decay=0.0), 88 weight(decay=0.0005), 87 bias(decay=0.0)
TensorBoard: model graph visualization added ✅
Image sizes 640 train, 640 val
Using 8 dataloader workers
Logging results to runs/detect/train5
Starting training for 100 epochs...

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size

      1/100      4.66G     0.9414      1.857      1.081         12        640: 100%|██████████| 124/124 [00:16<00:00,  7.31it/s]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 18/18 [00:02<00:00,  6.55it/s]

                   all        563       1342      0.564      0.449      0.469       0.33

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size

      2/100      4.65G      1.045      1.442      1.155         13        640: 100%|██████████| 124/124 [00:15<00:00,  8.03it/s]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 18/18 [00:02<00:00,  6.95it/s]

                   all        563       1342      0.589      0.504      0.509      0.337

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size

      3/100      4.69G      1.114      1.362      1.186         11        640: 100%|██████████| 124/124 [00:15<00:00,  8.10it/s]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 18/18 [00:02<00:00,  7.24it/s]

# Save train results in Google Drive
import shutil

source_folder = '/content/runs/detect/val'  # Path to your YOLO results folder
destination_folder = '/content/drive/MyDrive/yolo_training/detect/small_objects_aug_val'  # Desired path in Google Drive

shutil.move(source_folder, destination_folder)

'/content/drive/MyDrive/yolo_training/detect/small_objects_aug_val'

import matplotlib.pyplot as plt
import cv2

# Load the training results image
results_img_path = "/content/drive/MyDrive/yolo_training/detect/rand_div_100ep/results.png"
img = cv2.imread(results_img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB for correct visualization

# Display the image
plt.figure(figsize=(10,5))
plt.imshow(img)
plt.axis("off")  # Remove axis labels
plt.title("Training Results")
plt.show()

from ultralytics import YOLO
model = YOLO("/content/drive/MyDrive/yolo_training/detect/rand_div_100ep/weights/best.pt")  # load a custom model

# Validate the model
metrics = model.val(save_json=True, plots=True, save_txt=True, save_conf=True, save_crop=True)  # no arguments needed, dataset and settings remembered
metrics.box.map  # map50-95
metrics.box.map50  # map50
metrics.box.map75  # map75
metrics.box.maps  # a list contains map50-95 of each category

Ultralytics 8.3.99 🚀 Python-3.11.11 torch-2.6.0+cu124 CUDA:0 (NVIDIA L4, 22693MiB)
YOLO11n summary (fused): 100 layers, 2,582,347 parameters, 0 gradients, 6.3 GFLOPs
Downloading https://ultralytics.com/assets/Arial.ttf to '/root/.config/Ultralytics/Arial.ttf'...

100%|██████████| 755k/755k [00:00<00:00, 81.1MB/s]
val: Scanning /content/yolo_dataset/labels/val... 563 images, 0 backgrounds, 0 corrupt: 100%|██████████| 563/563 [00:00<00:00, 1346.56it/s]

val: New cache created: /content/yolo_dataset/labels/val.cache

                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 36/36 [00:14<00:00,  2.49it/s]

                   all        563       1342      0.739      0.727      0.759      0.571
Speed: 0.4ms preprocess, 2.6ms inference, 0.0ms loss, 1.3ms postprocess per image
Saving runs/detect/val2/predictions.json...
Results saved to runs/detect/val2

array([    0.57081])

import os
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from matplotlib.gridspec import GridSpec
import glob

def display_metrics_images(directory_path):
    """
    Display all PNG metric images from a specified directory in a grid layout.

    Args:
        directory_path (str): Path to the directory containing PNG metric images
    """
    # Get all PNG files in the directory
    png_files = glob.glob(os.path.join(directory_path, "*.png"))

    if not png_files:
        print(f"No PNG files found in {directory_path}")
        return

    # Sort files to ensure consistent display order
    png_files.sort()

    # Calculate grid dimensions based on number of images
    n_images = len(png_files)
    n_cols = min(2, n_images)  # Maximum 3 columns
    n_rows = (n_images + n_cols - 1) // n_cols  # Ceiling division

    # Create figure and GridSpec
    plt.figure(figsize=(15, 5 * n_rows))
    gs = GridSpec(n_rows, n_cols)

    # Plot each image
    for i, img_path in enumerate(png_files):
        row, col = divmod(i, n_cols)
        ax = plt.subplot(gs[row, col])

        # Read and display image
        img = mpimg.imread(img_path)
        ax.imshow(img)

        # Set title to filename without extension
        title = os.path.splitext(os.path.basename(img_path))[0]
        ax.set_title(title.replace('-', ' ').title())

        # Remove axis ticks
        ax.set_xticks([])
        ax.set_yticks([])

    plt.tight_layout()
    plt.suptitle("Model Validation Metrics", fontsize=20, y=1.02)
    plt.show()


metrics_dir = "/content/drive/MyDrive/yolo_training/detect/val2_rand_div_100ep"
display_metrics_images(metrics_dir)

import os
import json

labels_path = "/content/yolo_dataset/labels/val"
images = os.listdir(labels_path)

ground_truth = []
for file in images:
    if file.endswith(".txt"):
        img_id = file.replace(".txt", ".jpg")
        with open(os.path.join(labels_path, file), "r") as f:
            for line in f.readlines():
                parts = line.strip().split()
                class_id = int(parts[0])
                x, y, w, h = map(float, parts[1:])
                ground_truth.append({
                    "image_id": img_id,
                    "category_id": class_id,
                    "bbox": [x, y, w, h]
                })

with open("ground_truth.json", "w") as f:
    json.dump(ground_truth, f, indent=4)

def convert_gt_to_pixel_coords(ground_truth, images_dir):
  "Converts ground truth bounding boxes to pixel coordinates"

  converted_gt = []
  for gt_obj in ground_truth:
    image_id = gt_obj['image_id']
    # Find the image file
    image_path = os.path.join(images_dir, image_id)

    if not os.path.exists(image_path):
      raise FileNotFoundError(f"Image file not found: {image_path}")
    try:
      image = Image.open(image_path)
      image_width, image_height = image.size

      # Convert bounding box to pixel coordinates
      gt_bbox = gt_obj['bbox']
      x_min = int((gt_bbox[0] - gt_bbox[2] / 2) * image_width)
      y_min = int((gt_bbox[1] - gt_bbox[3] / 2) * image_height)
      x_max = int((gt_bbox[0] + gt_bbox[2] / 2) * image_width)
      y_max = int((gt_bbox[1] + gt_bbox[3] / 2) * image_height)

      # Update the bounding box in the ground truth object
      gt_obj['bbox'] = [x_min, y_min, x_max, y_max]
      converted_gt.append(gt_obj)

    except Exception as e:  # Handle exceptions for file not found, or PIL.UnidentifiedImageError
      print(f"Error with file {image_path}: {e}. skipping..")
  return converted_gt

gt_normalized = convert_gt_to_pixel_coords(ground_truth, "/content/content/yolo_dataset/images/val")
with open("gt_normalized.json", "w") as f:
    json.dump(gt_normalized, f, indent=4)

import shutil

source_folder = '/content/ground_truth.json'  # Path to your YOLO results folder
destination_folder = '/content/drive/MyDrive/yolo_training/detect/val2_rand_div_100ep/ground_truth.json'  # Desired path in Google Drive

shutil.move(source_folder, destination_folder)

'/content/drive/MyDrive/yolo_training/detect/val2_rand_div_100ep/ground_truth.json'

import json

# Define the file paths (update if needed)
gt_path = "/content/drive/MyDrive/yolo_training/detect/val2_rand_div_100ep/gt_converted.json"
pred_path = "/content/drive/MyDrive/yolo_training/detect/val2_rand_div_100ep/predictions.json"

# Load the JSON files
with open(gt_path, "r") as f:
    gt_converted = json.load(f)

with open(pred_path, "r") as f:
    predictions = json.load(f)

import json
import csv
from collections import defaultdict

def convert_bbox_pred(bbox):
    # [x, y, w, h] → [x_min, y_min, x_max, y_max]
    x, y, w, h = bbox
    return [x, y, x + w, y + h]

def convert_bbox_gt(bbox):
    # Already [x_min, y_min, x_max, y_max]
    return bbox

def iou(boxA, boxB):
    xA = max(boxA[0], boxB[0])
    yA = max(boxA[1], boxB[1])
    xB = min(boxA[2], boxB[2])
    yB = min(boxA[3], boxB[3])

    interArea = max(0, xB - xA) * max(0, yB - yA)
    boxAArea = max(0, boxA[2] - boxA[0]) * max(0, boxA[3] - boxA[1])
    boxBArea = max(0, boxB[2] - boxB[0]) * max(0, boxB[3] - boxB[1])

    union = boxAArea + boxBArea - interArea
    if union == 0:
        return 0
    return interArea / union


gt = gt_converted

# Group predictions by image_id
preds_by_image = defaultdict(list)
for pred in predictions:
    if pred["score"] >= 0.3:  #
        pred_box = convert_bbox_pred(pred["bbox"])
        preds_by_image[pred["image_id"]].append({
            "bbox": pred_box,
            "score": pred["score"]
        })

false_negatives = []

for gt_obj in gt:
    image_id = gt_obj["image_id"]
    gt_box = convert_bbox_gt(gt_obj["bbox"])

    matched = False
    for pred in preds_by_image.get(image_id, []):
        if iou(gt_box, pred["bbox"]) >= 0.5:
            matched = True
            break

    if not matched:
        fn_data = {
            "image_id": image_id,
            "x_min": gt_box[0],
            "y_min": gt_box[1],
            "x_max": gt_box[2],
            "y_max": gt_box[3],
            "width": gt_box[2] - gt_box[0],
            "height": gt_box[3] - gt_box[1]
        }
        false_negatives.append(fn_data)

# Save to CSV
with open("false_negatives.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=false_negatives[0].keys())
    writer.writeheader()
    writer.writerows(false_negatives)

print(f"🔍 Found {len(false_negatives)} false negatives out of {len(gt)} total ground-truth boxes.")

🔍 Found 364 false negatives out of 1342 total ground-truth boxes.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Load the CSV file with false negative bounding boxes
fn_df = pd.read_csv("false_negatives.csv")

# Compute area of each bounding box
fn_df["area"] = fn_df["width"] * fn_df["height"]

# Filter out the top 2% largest bounding boxes
threshold = fn_df["area"].quantile(0.92)
filtered_fn_df = fn_df[fn_df["area"] <= threshold]


# Calculate center coordinates of each bounding box
fn_df["x_center"] = fn_df["x_min"] + fn_df["width"] / 2
fn_df["y_center"] = fn_df["y_min"] + fn_df["height"] / 2


# Plot: Heatmap of object locations (2D histogram)
plt.figure(figsize=(10, 6))
plt.hist2d(fn_df["x_center"], fn_df["y_center"], bins=50, cmap="Reds")
plt.colorbar(label="Count")
plt.title("Heatmap of False Negative Object Locations")
plt.xlabel("X Center")
plt.ylabel("Y Center")
plt.tight_layout()
plt.show()

import os
import cv2
import pandas as pd

# Paths
labels_dir = "/content/yolo_dataset/labels/val"
images_dir = "/content/yolo_dataset/images/val"

# Prepare list to collect GT boxes
gt_boxes = []

# Iterate over all label files
for label_file in os.listdir(labels_dir):
    if not label_file.endswith(".txt"):
        continue

    image_id = os.path.splitext(label_file)[0]
    label_path = os.path.join(labels_dir, label_file)
    image_path = os.path.join(images_dir, image_id + ".jpg")  # or .png if needed

    if not os.path.exists(image_path):
        print(f"Image not found: {image_path}")
        continue

    # Load image to get width and height
    image = cv2.imread(image_path)
    if image is None:
        print(f"Failed to load image: {image_path}")
        continue

    image_height, image_width = image.shape[:2]

    # Read label lines
    with open(label_path, "r") as f:
        lines = f.readlines()

    for line in lines:
        parts = line.strip().split()
        if len(parts) != 5:
            continue

        class_id, x_center_norm, y_center_norm, width_norm, height_norm = map(float, parts)

        width = width_norm * image_width
        height = height_norm * image_height
        area = width * height

        gt_boxes.append({
            "image_id": image_id,
            "class_id": int(class_id),
            "width": width,
            "height": height,
            "area": int(area)
        })

# Convert to DataFrame
gt_df = pd.DataFrame(gt_boxes)

# Filter out the top 2% largest bounding boxes
threshold = gt_df["area"].quantile(0.95)
filtered_gt_df = gt_df[gt_df["area"] <= threshold]

#Normalized Distribution of Bounding Box Areas

import matplotlib.pyplot as plt
import seaborn as sns
import matplotlib.ticker as ticker

def normal_dist_gt_fn(gt_df, fn_df,area_filter=None):

  if area_filter is not None:
    gt_df = gt_df[gt_df["area"]<area_filter]
    fn_df = fn_df[fn_df["area"]<area_filter]

  # Create figure
  plt.figure(figsize=(10, 6))

  # Plot normalized histogram for GT areas
  sns.histplot(gt_df["area"], bins=50, color="blue", label="All Ground Truth", kde=False, stat="density", alpha=0.5)

  # Plot normalized histogram for FN areas
  sns.histplot(fn_df["area"], bins=50, color="red", label="False Negatives", kde=False, stat="density", alpha=0.5)

  # Title and labels
  plt.title("Normalized Distribution of Bounding Box Areas")
  plt.xlabel("Area (pixels)")
  plt.ylabel("Density")
  plt.grid(True)
  plt.legend()

  # Format x-axis with commas
  plt.gca().xaxis.set_major_formatter(ticker.FuncFormatter(lambda x, _: f"{int(x):,}"))

  plt.tight_layout()
  plt.show()

#Difference in Density of bounding box areas:

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

def density_diff_gt_fn(gt_df, fn_df,area_filter=None):
  if area_filter is not None:
    gt_df = gt_df[gt_df["area"]<area_filter]
    fn_df = fn_df[fn_df["area"]<area_filter]

  # Define common bin edges
  bins = np.linspace(0, max(gt_df["area"].max(), fn_df["area"].max()), 50)

  # Compute normalized histograms (density=True)
  gt_density, _ = np.histogram(gt_df["area"], bins=bins, density=True)
  fn_density, _ = np.histogram(fn_df["area"], bins=bins, density=True)

  # Compute bin centers for plotting
  bin_centers = 0.5 * (bins[1:] + bins[:-1])

  # Compute difference between densities
  density_diff = fn_density - gt_density

  # Plot the difference
  plt.figure(figsize=(10, 6))
  plt.bar(bin_centers, density_diff, width=(bins[1] - bins[0]), color="purple", alpha=0.7)
  plt.axhline(0, color='black', linestyle='--')
  plt.title("Difference in Density: False Negatives - Ground Truth")
  plt.xlabel("Bounding Box Area (pixels)")
  plt.ylabel("Density Difference")
  plt.grid(True)
  plt.gca().xaxis.set_major_formatter(ticker.FuncFormatter(lambda x, _: f"{int(x):,}"))
  plt.tight_layout()
  plt.show()

normal_dist_gt_fn(gt_df, fn_df,50000)

normal_dist_gt_fn(gt_df, fn_df,5000)

normal_dist_gt_fn(gt_df, fn_df,1000)

density_diff_gt_fn(gt_df, fn_df,1000)

import os
import cv2

# Define the image folder path
image_folder = "/content/images"

# Create a dictionary mapping image_id to image area (width × height)
image_area_dict = {}

for filename in os.listdir(image_folder):
    if filename.lower().endswith(('.jpg', '.jpeg', '.png')):
        image_id = os.path.splitext(filename)[0]
        img_path = os.path.join(image_folder, filename)
        img = cv2.imread(img_path)
        if img is not None:
            h, w = img.shape[:2]
            image_area_dict[image_id] = w * h

# Add relative_area column to both DataFrames
for df in [gt_df, fn_df]:
    df["relative_area"] = df.apply(
        lambda row: row["area"] / image_area_dict.get(str(row["image_id"]), 1), axis=1
    )

import numpy as np
import matplotlib.pyplot as plt

def cumulative_relative_fn_analysis(gt_df, fn_df, area_filter=None, num_bins=100):
    """
    Plots cumulative FN count and cumulative FN rate (relative to GT)
    as a function of object area.

    Parameters:
        gt_df (pd.DataFrame): Ground truth boxes DataFrame with 'area'
        fn_df (pd.DataFrame): False negative boxes DataFrame with 'area'
        area_filter (float or None): Optional upper area limit for filtering
        num_bins (int): Number of bins
    """

    # Apply optional area filter
    if area_filter is not None:
        gt_df = gt_df[gt_df["relative_area"] < area_filter]
        fn_df = fn_df[fn_df["relative_area"] < area_filter]

    # Create bins
    max_area = max(gt_df["relative_area"].max(), fn_df["relative_area"].max())
    bins = np.linspace(0, max_area, num_bins + 1)
    bin_centers = (bins[:-1] + bins[1:]) / 2

    # Histogram counts
    gt_hist, _ = np.histogram(gt_df["relative_area"], bins=bins)
    fn_hist, _ = np.histogram(fn_df["relative_area"], bins=bins)

    # Cumulative sums
    cumulative_gt = np.cumsum(gt_hist)
    cumulative_fn = np.cumsum(fn_hist)

    # Cumulative FN rate (avoid division by zero)
    cumulative_rate = np.where(cumulative_gt > 0, cumulative_fn / cumulative_gt * 100, np.nan)

    # Plot
    fig, ax1 = plt.subplots(figsize=(12, 6))

    # Plot cumulative FN count
    ax1.plot(bin_centers, cumulative_fn, color='green', marker='o', label='Cumulative FN Count')
    ax1.set_xlabel("Object Relative Area")
    ax1.set_ylabel("Cumulative FN Count", color='green')
    ax1.tick_params(axis='y', labelcolor='green')

    # Create second y-axis for FN rate
    ax2 = ax1.twinx()
    ax2.plot(bin_centers, cumulative_rate, color='blue',marker='o', label='Cumulative FN Rate (%)')
    ax2.set_ylabel("Cumulative FN Rate (%)", color='blue')
    ax2.tick_params(axis='y', labelcolor='blue')
    ax2.set_ylim(0, 100)

    # Title and grid
    plt.title("Cumulative FN Analysis by Object Relative Area")
    ax1.grid(True)

    fig.tight_layout()
    plt.show()

cumulative_relative_fn_analysis(gt_df, fn_df)

cumulative_relative_fn_analysis(gt_df, fn_df, 0.1)

cumulative_relative_fn_analysis(gt_df, fn_df, 0.01)

from ultralytics import YOLO
import os

model = YOLO('yolo11n')  # Load the YOLOv11n model

save_dir = "/content/drive/MyDrive/yolo_training"

results = model.train(
    data='/content/yolo_dataset/data.yaml',     # Path to dataset YAML
    patience = 30,
    save_dir=save_dir,
    imgsz=1024,                # Larger input size improves small object resolution
    epochs=150,                # More epochs for better convergence
    batch=8,                   # Reduce batch size if using larger images
    rect=True,                 # Enable rectangular batches to reduce padding (good for small object localization)
    multi_scale=True,         # Train on different image sizes to improve robustness
    close_mosaic=30,          # Turn off mosaic augmentation in the last 30 epochs for more stable training
    box=10.0,                  # Increase box loss weight to emphasize precise box localization
    cls=0.3,                   # Lower classification loss weight to avoid overfitting on background
    dfl=2.0,                   # Higher weight for distribution focal loss improves box regression
    name='small_objects_aug_exp',  # Name of the run
    device=0,                  # GPU index

    # Augmentation parameters for small objects
    degrees=0.0,               # Avoid rotation – small objects might rotate out of view
    translate=0.05,            # Minimal translation – preserves object position
    scale=0.4,                 # Slight scale variance – helps generalization
    shear=0.0,                 # Disable shearing – preserves object shape
    perspective=0.0,           # Avoid perspective transforms – keeps object geometry
    flipud=0.0,                # No vertical flipping – usually unnatural
    fliplr=0.5,                # Allow horizontal flipping
    mosaic=1.0,                # Keep mosaic – helpful for small object diversity
    mixup=0.1,                 # Light mixup – too much can obscure small objects
    copy_paste=0.1             # Light copy-paste augmentation – helpful to add more small object instances
)

Ultralytics 8.3.109 🚀 Python-3.11.12 torch-2.6.0+cu124 CUDA:0 (NVIDIA A100-SXM4-40GB, 40507MiB)
engine/trainer: task=detect, mode=train, model=yolo11n.pt, data=/content/yolo_dataset/data.yaml, epochs=150, time=None, patience=30, batch=8, imgsz=1024, save=True, save_period=-1, cache=False, device=0, workers=8, project=None, name=small_objects_aug_exp2, exist_ok=False, pretrained=True, optimizer=auto, verbose=True, seed=0, deterministic=True, single_cls=False, rect=True, cos_lr=False, close_mosaic=30, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=True, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=True, opset=None, workspace=None, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=10.0, cls=0.3, dfl=2.0, pose=12.0, kobj=1.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.05, scale=0.4, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.1, copy_paste=0.1, copy_paste_mode=flip, auto_augment=randaugment, erasing=0.4, cfg=None, tracker=botsort.yaml, save_dir=runs/detect/small_objects_aug_exp2
Overriding model.yaml nc=80 with nc=1

                   from  n    params  module                                       arguments                     
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]                 
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]                
  2                  -1  1      6640  ultralytics.nn.modules.block.C3k2            [32, 64, 1, False, 0.25]      
  3                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]                
  4                  -1  1     26080  ultralytics.nn.modules.block.C3k2            [64, 128, 1, False, 0.25]     
  5                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              
  6                  -1  1     87040  ultralytics.nn.modules.block.C3k2            [128, 128, 1, True]           
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]              
  8                  -1  1    346112  ultralytics.nn.modules.block.C3k2            [256, 256, 1, True]           
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]                 
 10                  -1  1    249728  ultralytics.nn.modules.block.C2PSA           [256, 256, 1]                 
 11                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 12             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 13                  -1  1    111296  ultralytics.nn.modules.block.C3k2            [384, 128, 1, False]          
 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 15             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 16                  -1  1     32096  ultralytics.nn.modules.block.C3k2            [256, 64, 1, False]           
 17                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]                
 18            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 19                  -1  1     86720  ultralytics.nn.modules.block.C3k2            [192, 128, 1, False]          
 20                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              
 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 22                  -1  1    378880  ultralytics.nn.modules.block.C3k2            [384, 256, 1, True]           
 23        [16, 19, 22]  1    430867  ultralytics.nn.modules.head.Detect           [1, [64, 128, 256]]           
YOLO11n summary: 181 layers, 2,590,035 parameters, 2,590,019 gradients, 6.4 GFLOPs

Transferred 448/499 items from pretrained weights
TensorBoard: Start with 'tensorboard --logdir runs/detect/small_objects_aug_exp2', view at http://localhost:6006/
Freezing layer 'model.23.dfl.conv.weight'
AMP: running Automatic Mixed Precision (AMP) checks...
AMP: checks passed ✅

train: Scanning /content/yolo_dataset/labels/train.cache... 1971 images, 0 backgrounds, 0 corrupt: 100%|██████████| 1971/1971 [00:00<?, ?it/s]

albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1.0, 4.0), tile_grid_size=(8, 8))
WARNING ⚠️ 'rect=True' is incompatible with DataLoader shuffle, setting shuffle=False

val: Scanning /content/yolo_dataset/labels/val.cache... 563 images, 0 backgrounds, 0 corrupt: 100%|██████████| 563/563 [00:00<?, ?it/s]

Plotting labels to runs/detect/small_objects_aug_exp2/labels.jpg... 
optimizer: 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... 
optimizer: AdamW(lr=0.002, momentum=0.9) with parameter groups 81 weight(decay=0.0), 88 weight(decay=0.0005), 87 bias(decay=0.0)
TensorBoard: model graph visualization added ✅
Image sizes 1024 train, 1024 val
Using 8 dataloader workers
Logging results to runs/detect/small_objects_aug_exp2
Starting training for 150 epochs...

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size

      1/150      7.98G      1.505      1.827      1.685          7        288: 100%|██████████| 247/247 [00:42<00:00,  5.81it/s]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 36/36 [00:03<00:00,  9.50it/s]

                   all        563       1342      0.348      0.294      0.245      0.147

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size

      2/150      7.99G      1.781      1.448      1.939          7        608: 100%|██████████| 247/247 [00:40<00:00,  6.03it/s]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 36/36 [00:02<00:00, 12.01it/s]

                   all        563       1342      0.213      0.227      0.127     0.0664

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size

      3/150      8.01G      1.821      1.211       1.98          7        736: 100%|██████████| 247/247 [00:40<00:00,  6.05it/s]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 36/36 [00:03<00:00, 11.63it/s]

import matplotlib.pyplot as plt
import cv2

# Load the training results image
results_img_path = "/content/drive/MyDrive/yolo_training/detect/small_objects_aug/results.png"
img = cv2.imread(results_img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB for correct visualization

# Display the image
plt.figure(figsize=(10,5))
plt.imshow(img)
plt.axis("off")  # Remove axis labels
plt.title("Training Results")
plt.show()

from ultralytics import YOLO
model = YOLO("/content/drive/MyDrive/yolo_training/detect/small_objects_aug/weights/best.pt")  # load a custom model

# Validate the model
metrics = model.val(save_json=True, plots=True, save_txt=True, save_conf=True, save_crop=True)  # no arguments needed, dataset and settings remembered
metrics.box.map  # map50-95
metrics.box.map50  # map50
metrics.box.map75  # map75
metrics.box.maps  # a list contains map50-95 of each category

Ultralytics 8.3.109 🚀 Python-3.11.12 torch-2.6.0+cu124 CUDA:0 (NVIDIA A100-SXM4-40GB, 40507MiB)
YOLO11n summary (fused): 100 layers, 2,582,347 parameters, 0 gradients, 6.3 GFLOPs

val: Scanning /content/yolo_dataset/labels/val.cache... 563 images, 0 backgrounds, 0 corrupt: 100%|██████████| 563/563 [00:00<?, ?it/s]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 36/36 [00:14<00:00,  2.51it/s]

                   all        563       1342      0.765      0.704      0.767      0.576
Speed: 0.7ms preprocess, 2.8ms inference, 0.0ms loss, 0.9ms postprocess per image
Saving runs/detect/val/predictions.json...
Results saved to runs/detect/val

array([    0.57611])

metrics_dir = '/content/drive/MyDrive/yolo_training/detect/small_objects_aug_val'
display_metrics_images(metrics_dir)

import json

pred_path = "/content/drive/MyDrive/yolo_training/detect/small_objects_aug_val/predictions.json"

with open(pred_path, "r") as f:
    predictions_small_aug = json.load(f)

# Group predictions by image_id
preds_by_image_retrain = defaultdict(list)
for pred in predictions_small_aug:
    if pred["score"] >= 0.3:
        pred_box = convert_bbox_pred(pred["bbox"])
        preds_by_image_retrain[pred["image_id"]].append({
            "bbox": pred_box,
            "score": pred["score"]
        })

false_negatives_retrain = []

for gt_obj in gt:
    image_id = gt_obj["image_id"]
    gt_box = convert_bbox_gt(gt_obj["bbox"])

    matched = False
    for pred in preds_by_image_retrain.get(image_id, []):
        if iou(gt_box, pred["bbox"]) >= 0.5:
            matched = True
            break

    if not matched:
        fn_data = {
            "image_id": image_id,
            "x_min": gt_box[0],
            "y_min": gt_box[1],
            "x_max": gt_box[2],
            "y_max": gt_box[3],
            "width": gt_box[2] - gt_box[0],
            "height": gt_box[3] - gt_box[1]
        }
        false_negatives_retrain.append(fn_data)

print(f"🔍 Found {len(false_negatives)} false negatives out of {len(gt)} total ground-truth boxes.")

🔍 Found 364 false negatives out of 1342 total ground-truth boxes.

normal_dist_gt_fn(gt_df, fn_df,50000)

normal_dist_gt_fn(gt_df, fn_df,5000)

cumulative_relative_fn_analysis(gt_df, fn_df, 0.1)

Introduction¶

Background¶

YOLO (You Only Look Once)¶

Project Goals¶

Data Collection¶

Data Validation¶

Results¶

Exploratory Data Analysis (EDA)¶

General Stats¶

Label Format¶

Class Distribution¶

Visualizing Bounding Boxes¶

Object Size Analysis¶

Investigate Outliers¶

Object Size Relative to Image¶

Characteristics Analysis¶

Shapes¶

Colors¶

Data Preperation¶

Label Format Conversion¶

Data Splitting¶

Split Validation¶

Create configuration file¶

Model Training¶

Training Setup¶

Training Results Analysis¶

Loss Analysis¶

Precision and Recall¶

mAP (Mean Average Precision)¶

Conclusion¶

Model Evaluation and Refinement¶

Validation Summary¶

False Negatives Analysis¶

Object Size Analysis¶

Re-Train¶

Evaluation¶

FN Analysis¶

Conclusion¶

Project Summary: Traffic Sign Detection using YOLO¶

Methodology:¶

Results:¶

Potential Improvements:¶

Future Directions:¶